package services

import (
	"fmt"
	"time"

	"go.uber.org/zap"
	"golang.org/x/crypto/bcrypt"

	"dcarpai-guider/internal/middleware"
	"dcarpai-guider/internal/models"
	"dcarpai-guider/internal/utils"
)

// UserService 用户服务
type UserService struct {
	fileManager *utils.FileManager
	logger      *zap.Logger
	dataPath    string
}

// NewUserService 创建新的用户服务
func NewUserService(fileManager *utils.FileManager, logger *zap.Logger) *UserService {
	return &UserService{
		fileManager: fileManager,
		logger:      logger,
		dataPath:    "data/users.json",
	}
}

// Login 用户登录
func (us *UserService) Login(username, password string) (*models.LoginResponse, error) {
	us.logger.Info("尝试用户登录", zap.String("username", username))

	// 读取用户数据
	var users []models.User
	if err := us.fileManager.ReadJSON(us.dataPath, &users); err != nil {
		us.logger.Error("读取用户数据失败", zap.Error(err))
		return nil, fmt.Errorf("读取用户数据失败: %w", err)
	}

	// 查找用户
	var user *models.User
	for i := range users {
		if users[i].Username == username {
			user = &users[i]
			break
		}
	}

	if user == nil {
		us.logger.Warn("用户不存在", zap.String("username", username))
		return nil, fmt.Errorf("用户名或密码错误")
	}

	// 验证密码
	if err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(password)); err != nil {
		us.logger.Warn("密码验证失败", zap.String("username", username))
		return nil, fmt.Errorf("用户名或密码错误")
	}

	// 更新最后登录时间
	user.LastLogin = time.Now().Format(time.RFC3339)
	if err := us.updateUser(users, user); err != nil {
		us.logger.Error("更新用户登录时间失败", zap.Error(err))
		// 这里不返回错误，因为登录本身是成功的
	}

	// 生成JWT token
	token, err := middleware.GenerateToken(user.ID, user.Username, user.Role)
	if err != nil {
		us.logger.Error("生成token失败", zap.Error(err))
		return nil, fmt.Errorf("生成token失败: %w", err)
	}

	us.logger.Info("用户登录成功",
		zap.String("username", username),
		zap.String("role", user.Role),
	)

	// 返回登录响应
	response := &models.LoginResponse{
		Token: token,
		User: models.UserResponse{
			ID:        user.ID,
			Username:  user.Username,
			Role:      user.Role,
			Email:     user.Email,
			Created:   user.Created,
			LastLogin: user.LastLogin,
		},
	}

	return response, nil
}

// GetUserProfile 获取用户信息
func (us *UserService) GetUserProfile(userID int) (*models.UserResponse, error) {
	var users []models.User
	if err := us.fileManager.ReadJSON(us.dataPath, &users); err != nil {
		us.logger.Error("读取用户数据失败", zap.Error(err))
		return nil, fmt.Errorf("读取用户数据失败: %w", err)
	}

	// 查找用户
	for _, user := range users {
		if user.ID == userID {
			return &models.UserResponse{
				ID:        user.ID,
				Username:  user.Username,
				Role:      user.Role,
				Email:     user.Email,
				Created:   user.Created,
				LastLogin: user.LastLogin,
			}, nil
		}
	}

	return nil, fmt.Errorf("用户不存在")
}

// GetAllUsers 获取所有用户（管理员功能）
func (us *UserService) GetAllUsers() ([]models.UserResponse, error) {
	var users []models.User
	if err := us.fileManager.ReadJSON(us.dataPath, &users); err != nil {
		us.logger.Error("读取用户数据失败", zap.Error(err))
		return nil, fmt.Errorf("读取用户数据失败: %w", err)
	}

	var responses []models.UserResponse
	for _, user := range users {
		responses = append(responses, models.UserResponse{
			ID:        user.ID,
			Username:  user.Username,
			Role:      user.Role,
			Email:     user.Email,
			Created:   user.Created,
			LastLogin: user.LastLogin,
		})
	}

	return responses, nil
}

// CreateUser 创建新用户（管理员功能）
func (us *UserService) CreateUser(username, password, role, email string) (*models.UserResponse, error) {
	var users []models.User
	if err := us.fileManager.ReadJSON(us.dataPath, &users); err != nil {
		us.logger.Error("读取用户数据失败", zap.Error(err))
		return nil, fmt.Errorf("读取用户数据失败: %w", err)
	}

	// 检查用户名是否已存在
	for _, user := range users {
		if user.Username == username {
			return nil, fmt.Errorf("用户名已存在")
		}
	}

	// 加密密码
	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
	if err != nil {
		us.logger.Error("密码加密失败", zap.Error(err))
		return nil, fmt.Errorf("密码加密失败: %w", err)
	}

	// 生成新的用户ID
	maxID := 0
	for _, user := range users {
		if user.ID > maxID {
			maxID = user.ID
		}
	}

	// 创建新用户
	newUser := models.User{
		ID:       maxID + 1,
		Username: username,
		Password: string(hashedPassword),
		Role:     role,
		Email:    email,
		Created:  time.Now().Format(time.RFC3339),
	}

	// 添加到用户列表
	users = append(users, newUser)

	// 保存到文件
	if err := us.fileManager.WriteJSON(us.dataPath, users); err != nil {
		us.logger.Error("保存用户数据失败", zap.Error(err))
		return nil, fmt.Errorf("保存用户数据失败: %w", err)
	}

	us.logger.Info("创建用户成功",
		zap.String("username", username),
		zap.String("role", role),
	)

	return &models.UserResponse{
		ID:       newUser.ID,
		Username: newUser.Username,
		Role:     newUser.Role,
		Email:    newUser.Email,
		Created:  newUser.Created,
	}, nil
}

// updateUser 更新用户信息
func (us *UserService) updateUser(users []models.User, updatedUser *models.User) error {
	// 更新用户列表中的用户信息
	for i := range users {
		if users[i].ID == updatedUser.ID {
			users[i] = *updatedUser
			break
		}
	}

	// 保存到文件
	if err := us.fileManager.WriteJSON(us.dataPath, users); err != nil {
		return fmt.Errorf("保存用户数据失败: %w", err)
	}

	return nil
}
